/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package trunk.model;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.ImageIcon;
import trunk.model.calendar.Event;

/**
 *
 * @author Karine
 */
//Classe responsável por tratar todos os pacotes
public class TrataCliente implements Runnable {

	private ObjectOutputStream output;
	private ObjectInputStream input;
	private Socket conexao;
	private File arquivoClientes;
	private File arquivoCompromissos;
	private ObjectOutputStream clientesOutput;
	private ObjectInputStream clientesInput;
	private ObjectOutputStream compromissosOutput;
	private Cliente usuario;
        

	public TrataCliente(Socket cliente) {
		this.conexao = cliente;
	}

	//TODO Encerrar a conexão
	public void run() {

		try {
			System.out.println("Entro no método run da thread");

			obtemStreams();//Obtem streams para envio e recebimento de pacotes
			try {

				processaConexao(); //Chama método que processa o pacote

			} catch (Exception ex) {
				System.out.println("Problemas ao processar a conexao");
				Logger.getLogger(TrataCliente.class.getName()).log(Level.SEVERE, null, ex);
			}
		} catch (IOException ex) {
			Logger.getLogger(TrataCliente.class.getName()).log(Level.SEVERE, null, ex);
		}


	}

	public void obtemStreams() throws IOException {

		//configura o fluxo de saída para objetos
		output = new ObjectOutputStream(conexao.getOutputStream());
		//output.flush(); 
		// configura o fluxo de entrada para objetos
		input = new ObjectInputStream(conexao.getInputStream());

		//ExibirMessagem("Streams de dados obstidos com Sucesso para o servidor!/n");
	}

	public void processaConexao() throws IOException {

		Pacote pacoteRecebido;

		try {
			while (!conexao.isClosed()) {// Enquanto a conexão não estiver fechada
				pacoteRecebido = (Pacote) input.readObject(); // Ler o pacote recebido do cliente
				//--------------AQUI COMEÇA UMA CASCATA DE IFs PARA SABER O TIPO DO PACOTE------------------------------

				//Verificando o tipo de Requisição:
				//Se a Requisição for um CADASTRO:
				if (pacoteRecebido.getTipo() == TipoPacote.CADASTRO) {

					//é um cliente para ser inserido no banco de dados
					Cliente cadastro = (Cliente) pacoteRecebido.getConteudo();
					BancoDeClientes bancoDeClientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
					if (bancoDeClientes.inserirCliente(cadastro)) {
						ProgramServer.setBancoDeClientes(bancoDeClientes);
						System.out.println("Cliente Cadastrado no Banco de Clientes");
						arquivoClientes = new File("clientes.bin");
						clientesOutput = new ObjectOutputStream(new FileOutputStream(arquivoClientes));
						clientesOutput.writeObject(bancoDeClientes);
						clientesOutput.flush();
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_CADASTRO, bancoDeClientes);
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						encerrarConexao();
					} else {
						System.out.println("Cliente não pôde ser cadastrado");
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.FALHA_LOGIN, "FALHA");
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						encerrarConexao();
					}
				}//Se a Requisição for para EXCLUIR UM CADASTRO:
				else if (pacoteRecebido.getTipo() == TipoPacote.EXCLUIR_CADASTRO) {

					Pacote pacoteConfirmacao;

					Cliente excluirCadastro = (Cliente) pacoteRecebido.getConteudo();
					System.out.println("Exclusão de cadastro realizada com Sucesso 1");
					//Carrega o arquivo de clientes na memória
					FileInputStream arqClientes = new FileInputStream("clientes.bin");
					ObjectInputStream banco = new ObjectInputStream(arqClientes);
					BancoDeClientes bancoDeClientes = (BancoDeClientes) banco.readObject();
					System.out.println("Exclusão de cadastro realizada com Sucesso 2");
					//Exclui o cliente do banco de clientes
					if (bancoDeClientes.excluirCliente(excluirCadastro)) {

						//Seta o banco de clientes novamente no servidor
						ProgramServer.setBancoDeClientes(bancoDeClientes);
						System.out.println("Exclusão de cadastro realizada com Sucesso 3");
						//regrava o arquivo
						arquivoClientes = new File("clientes.bin");
						clientesOutput = new ObjectOutputStream(new FileOutputStream(arquivoClientes));
						clientesOutput.writeObject(bancoDeClientes);
						clientesOutput.flush();

						//Manda o pacote de volta
						HashMap<String, Object> conteudo = new HashMap<String, Object>();
						conteudo.put("clientes", bancoDeClientes);
						pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_EXCLUIR_CADASTRO, conteudo);
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						System.out.println("Exclusão de cadastro realizada com Sucesso  4");
						encerrarConexao();
					}
				} //Se a Requisição for para EXCLUIR UM COMPROMISSO:
				//EXCLUSAO DE COMPROMISSO
				else if (pacoteRecebido.getTipo() == TipoPacote.EXCLUIR_COMPROMISSO) {

					Pacote pacoteConfirmacao;

					int IDremover = (Integer) pacoteRecebido.getConteudo();
					System.out.println("Exclusão de compromisso realizada com Sucesso 1");

					//Carrega o arquivo de compromissos na memória
					FileInputStream arqCompromissos = new FileInputStream("compromissos.bin");
					ObjectInputStream banco = new ObjectInputStream(arqCompromissos);
					BancoDeCompromissos bancoDeCompromissos = (BancoDeCompromissos) banco.readObject();

					System.out.println("Exclusão de compromisso realizada com Sucesso 2");
					//Exclui o cliente do banco de clientes
					if (bancoDeCompromissos.excluirCompromisso(IDremover)) {

						//Seta o banco de compromissos novamente no servidor
						ProgramServer.setBancoDeCompromissos(bancoDeCompromissos);
						System.out.println("Exclusão de compromisso realizada com Sucesso 3");

						//regrava o arquivo
						arquivoCompromissos = new File("compromissos.bin");
						compromissosOutput = new ObjectOutputStream(new FileOutputStream(arquivoCompromissos));
						compromissosOutput.writeObject(bancoDeCompromissos);
						compromissosOutput.flush();
						compromissosOutput.close();

						//Manda o pacote de volta
						pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_EXCLUIR_COMPROMISSO, bancoDeCompromissos);
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						System.out.println("Exclusão de compromisso realizada com Sucesso  no Servidor ");
					}

				} //Se a Requisição for um LOGIN:
				else if (pacoteRecebido.getTipo() == TipoPacote.LOGIN) {

					Pacote pacoteConfirmacao;
					//é um cliente para ser buscado no banco de clientes
					Cliente buscarCadastro = (Cliente) pacoteRecebido.getConteudo();
					usuario = buscarCadastro; // Copio para usuario, quem é o cliente que está logando no momento (isso é necessário para o caso do usuário fechar a janela)
					BancoDeClientes bancoDeClientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
					if (bancoDeClientes.autentica(buscarCadastro)) {
						ProgramServer.setBancoDeClientes(bancoDeClientes);
						HashMap<String, Object> conteudo = new HashMap<String, Object>();
						conteudo.put("clientes", bancoDeClientes);
						conteudo.put("compromissos", ProgramServer.getBancoDeCompromissos());
						pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_LOGIN, conteudo);
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						System.out.println("Busca realizada com Sucesso: " + buscarCadastro.getStatus());

					} else {//Se Cliente não existe no bancoDeClientes:                           
						pacoteConfirmacao = new Pacote(TipoPacote.NAO_CADASTRADO, "SEM SUCESSO");
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						encerrarConexao();
					}
				} //Se a Requisição for um ALTERAR_IP
				else if (pacoteRecebido.getTipo() == TipoPacote.ADICIONAR_IP) {

					Pacote pacoteConfirmacao;
					//é um cliente para ser buscado no banco de clientes
					Cliente buscarCadastro = (Cliente) pacoteRecebido.getConteudo();
					BancoDeClientes bancoDeClientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
					if (bancoDeClientes.autentica(buscarCadastro)) {
						ProgramServer.setBancoDeClientes(bancoDeClientes);
						pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_IP_ADICIONADO, "SUCESSO");
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente

					} else {//Se Cliente não existe no bancoDeClientes:                           
						pacoteConfirmacao = new Pacote(TipoPacote.NAO_CADASTRADO, "SEM SUCESSO");
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						encerrarConexao();
					}
				}
				else if (pacoteRecebido.getTipo() == TipoPacote.ALTERAR_STATUS){
					Pacote pacoteConfirmacao;

					Cliente cliente = (Cliente) pacoteRecebido.getConteudo();
					BancoDeClientes bancoDeClientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
					if(bancoDeClientes.setStatusCliente(cliente)){
						ProgramServer.setBancoDeClientes(bancoDeClientes);
						pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_ALTERAR_STATUS, bancoDeClientes);
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						System.out.println("status atualizado com Sucesso: " + cliente.getStatus());

					} else {//Se Cliente não existe no bancoDeClientes:                           
						pacoteConfirmacao = new Pacote(TipoPacote.FALHA_ALTERAR_STATUS, "SEM SUCESSO");
						enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente
						encerrarConexao();
					}
				} //Se a Requisição for para CADASTRAR UM COMPROMISSO:
				else if (pacoteRecebido.getTipo() == TipoPacote.CADASTRAR_COMPROMISSO) {
					Event cadastro = (Event) pacoteRecebido.getConteudo();
					BancoDeCompromissos bancoDeCompromissos = new BancoDeCompromissos(ProgramServer.getBancoDeCompromissos());
					if (bancoDeCompromissos.inserirCompromisso(cadastro)) {
						ProgramServer.setBancoDeCompromissos(bancoDeCompromissos);
						System.out.println("Compromisso cadastrado no banco");
						arquivoCompromissos = new File("compromissos.bin");
						compromissosOutput = new ObjectOutputStream(new FileOutputStream(arquivoCompromissos));
						compromissosOutput.writeObject(bancoDeCompromissos);
						compromissosOutput.flush();
						compromissosOutput.close();
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_NOVO_COMPROMISSO,
								new BancoDeCompromissos(bancoDeCompromissos));
						enviarMsn(pacoteConfirmacao);
					} else {
						System.out.println("Compromisso não cadastrado");
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.FALHA_NOVO_COMPROMISSO, "FALHA");
						enviarMsn(pacoteConfirmacao);
					}

				} //Se a Requisição for para EDITAR UM COMPROMISSO:
				else if (pacoteRecebido.getTipo() == TipoPacote.EDITAR_COMPROMISSO) {
					HashMap<String, Object> conteudo = (HashMap<String, Object>) pacoteRecebido.getConteudo();
					Event cadastro = (Event) conteudo.get("evento");
					int IDremover = (Integer) conteudo.get("IDremover");
					BancoDeCompromissos bancoDeCompromissos = new BancoDeCompromissos(ProgramServer.getBancoDeCompromissos());
					bancoDeCompromissos.excluirCompromisso(IDremover);
					if (bancoDeCompromissos.inserirCompromisso(cadastro)) {
						ProgramServer.setBancoDeCompromissos(bancoDeCompromissos);
						System.out.println("Compromisso cadastrado no banco");
						arquivoCompromissos = new File("compromissos.bin");
						compromissosOutput = new ObjectOutputStream(new FileOutputStream(arquivoCompromissos));
						compromissosOutput.writeObject(bancoDeCompromissos);
						compromissosOutput.flush();
						compromissosOutput.close();
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_NOVO_COMPROMISSO,
								new BancoDeCompromissos(bancoDeCompromissos));
						enviarMsn(pacoteConfirmacao);
					} else {
						System.out.println("Compromisso não cadastrado");
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.FALHA_NOVO_COMPROMISSO, "FALHA");
						enviarMsn(pacoteConfirmacao);
					}

				} //Se a Requisição for para  ATUALIZAR STATUS DE CLIENTES:
				else if (pacoteRecebido.getTipo() == TipoPacote.ATUALIZAR_STATUS) {
					// System.out.println("Cliente pediu para atualizar o Status");

					HashMap<String, Object> conteudo = new HashMap<String, Object>();
					BancoDeClientes clientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
					BancoDeCompromissos compromissos = new BancoDeCompromissos(ProgramServer.getBancoDeCompromissos());
					System.out.println();
					System.out.println("Atualizando para conex�o de porta: " + conexao.getPort());
					/*for (Cliente cliente : clientes) {
						System.out.println(cliente.getNome() + " status:" + cliente.getStatus());
					}*/
					conteudo.put("clientes", clientes);
					conteudo.put("compromissos", compromissos);
					//Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_ATUALIZAR_STATUS,new BancoDeClientes(bancoDeClientes));
					Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_ATUALIZAR_STATUS, conteudo);
					enviarMsn(pacoteConfirmacao);
					// System.out.println("Enviou pacote do servidor para atualizar o Status");


				} //Se a Requisição for para  ENCERRAR A CONEXÃO COM LOGOUT:
				else if (pacoteRecebido.getTipo() == TipoPacote.ENCERRAR_CONEXAO_LOGOUT) {
					System.out.println("Cliente pediu para fazer logout do sistema");
					Cliente mudarStatusCliente = (Cliente) pacoteRecebido.getConteudo();
					System.out.println("ANTES: " + mudarStatusCliente.getStatus());
					BancoDeClientes bancoDeClientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
					if (bancoDeClientes.clienteOff(mudarStatusCliente)) {//Muda Status do Cliente para offline
						ProgramServer.setBancoDeClientes(bancoDeClientes);
						System.out.println("DEPOIS: " + mudarStatusCliente.getStatus());
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_ENCERRAR_CONEXAO_LOGOUT, "SUCESSO_LOGOUT");
						enviarMsn(pacoteConfirmacao);
						encerrarConexao(); // encerra a conexão com o cliente
					}
				}//Se a Requisição for para  ENCERRAR A CONEXÃO COM SAIR:
				else if (pacoteRecebido.getTipo() == TipoPacote.ENCERRAR_CONEXAO_SAIR) {
					System.out.println("Cliente pediu para SAIR do sistema");
					Cliente mudarStatusCliente = (Cliente) pacoteRecebido.getConteudo();
					System.out.println("ANTES: " + mudarStatusCliente.getStatus());
					BancoDeClientes bancoDeClientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
					if (bancoDeClientes.clienteOff(mudarStatusCliente)) {//Muda Status do Cliente para offline
						ProgramServer.setBancoDeClientes(bancoDeClientes);
						System.out.println("DEPOIS: " + mudarStatusCliente.getStatus());
						Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_ENCERRAR_CONEXAO_SAIR, "SUCESSO_SAIR");
						enviarMsn(pacoteConfirmacao);
						encerrarConexao(); // encerra a conexão com o cliente
					}
				} else if  (pacoteRecebido.getTipo() == TipoPacote.ENVIAR_ANEXO_SERVIDOR) {
					System.out.println("Cliente Enviará anexo ao sistema");
					Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_NOVO_COMPROMISSO, "SUCESSO");
					enviarMsn(pacoteConfirmacao);

					try {
						ServerSocket server = new ServerSocket(5678);
						Socket clSocket = server.accept();

						InputStream in = clSocket.getInputStream();

						InputStreamReader isr = new InputStreamReader(in);

						BufferedReader reader = new BufferedReader(isr);

						String fName = reader.readLine();

						System.out.println(fName);

						File f1 = new File(fName);

						FileOutputStream out = new FileOutputStream(f1);
						System.out.println(f1.getAbsolutePath());
						int tamanho = 462312; // buffer de 4KB
						byte[] buffer = new byte[tamanho];
						int lidos = -1;                                        
						while ((lidos = in.read(buffer, 0, tamanho)) > 0) {
							out.write(buffer, 0, lidos);
						}
						out.flush();
						in.close();
						out.close();
						server.close();
					} catch (IOException e) {
						e.printStackTrace();
					}                                       

				}else if(pacoteRecebido.getTipo() == TipoPacote.DOWNLOAD_ANEXO){
					Pacote pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_NOVO_COMPROMISSO, "SUCESSO");
					enviarMsn(pacoteConfirmacao);

					String arquivo =  (String) pacoteRecebido.getConteudo();

					File file = new File(arquivo);                        

					FileInputStream in = new FileInputStream(file);

					Socket socket = new Socket(pacoteRecebido.getEndrecoOrigem(), 56782);

					OutputStream out = socket.getOutputStream();

					OutputStreamWriter osw = new OutputStreamWriter(out);

					BufferedWriter writer = new BufferedWriter(osw);

					writer.write(file.getName() + "\n");

					writer.flush();

					int tamanho = 462312; // buffer de 4KB
					byte[] buffer = new byte[tamanho];
					int lidos = -1;
					int total = 0;
					while ((lidos = in.read(buffer, 0, tamanho)) > 0) {
						out.write(buffer, 0, lidos);
						total = total + lidos;
					}
					out.flush();
					in.close();
					out.close();
					socket.close();       
				          
                                
                                 //SE A REQUISIÇÃO FOR PELAS PESSOAS QUE ESTÃO ONLINE:       
                                }else if(pacoteRecebido.getTipo() == TipoPacote.SOLICITA_ONLINES){
                                       

                                        HashMap<String, Object> conteudo = new HashMap<String, Object>();
					BancoDeClientes Banco = new BancoDeClientes(ProgramServer.getBancoDeClientes());
                                        BancoDeClientes novoBancoON = new BancoDeClientes();
                                      
                                        for(Cliente aux :  Banco ){
                                            
                                            if(aux.getStatus() == TipoStatus.ONLINE)  {
                                                     novoBancoON.inserirCliente(aux);
                                                     System.out.println(aux.getNome() + aux.getStatus());
                                            }  
       
                                        }
                                        
                                      //Manda o pacote de volta	
                                            conteudo.put("clientes",novoBancoON);
                                            Pacote pacoteConfirmacao;
                                            pacoteConfirmacao = new Pacote(TipoPacote.SUCESSO_ONLINES, conteudo);
                                            enviarMsn(pacoteConfirmacao);//Envia confirmação para o cliente 
                                            
                                            
                                 //SE A REQUISÃO FOR PARA UMA SALA DO CHAT DO SERVIDOR:           
                                }else if(pacoteRecebido.getTipo() == TipoPacote.REQUISITAR_SALA_CHAT){                                       
                                    System.out.println("Entrou no servidor");
                                        //Verifica se a pessoa já não está em duas salas de chat:
                                    
                                        //Verifica se o servidor contém salas de chat disponíveis:
                                        int quantSalas_Chat = ProgramServer.getNumSalasChat();
                                         Pacote pacoteConfirmacao;
                                        
                                        if(quantSalas_Chat>0 && quantSalas_Chat<4){
                                            
                                            System.out.println("Existem Salas Disponíveis no Servidor: " + quantSalas_Chat);
                                            quantSalas_Chat--;
                                            ProgramServer.setNumSalasChat(quantSalas_Chat);//Decrementa um sala do servidor
                                            System.out.println("Uma sala foi decrementada: " + ProgramServer.getNumSalasChat());
                                            
                                            Cliente convidador = (Cliente) pacoteRecebido.getConteudo();
                                            ProgramServer.addDonosSalaChat(convidador);
                                            
                                            System.out.println("Agora os usuários que estão usando as salas de chat são: "+ ProgramServer.getDonosSalaChat());
                                            
                                            pacoteConfirmacao = new Pacote(TipoPacote.TEM_SALA_CHAT, "TEM_SALA_CHAT");
                                            enviarMsn(pacoteConfirmacao);
                                        
                                        }
                                        else{
                                            pacoteConfirmacao = new Pacote(TipoPacote.NEGADO_SALA_CHAT, "SALA_CHAT_NEGADA");
                                            enviarMsn(pacoteConfirmacao);
                                            System.out.println("Não Há Salas de Chat Disponíveis no Servidor");
                                        }  
                                        
                                //SE A REQUISÃO FOR PARA LIBERAR A SALA DE CHAT:           
                                }else if(pacoteRecebido.getTipo() == TipoPacote.LIBERAR_SALA_CHAT){
                                    
                                        //Verifica se o servidor contém salas de chat disponíveis:
                                        int quantSalas_Chat = ProgramServer.getNumSalasChat();
                                         Pacote pacoteConfirmacao;
                                         
                                         Cliente usuario = (Cliente) pacoteRecebido.getConteudo();
                                         boolean resultado = ProgramServer.getDonosSalaChat().contains(usuario);
                                         System.out.println("Resultado é "+resultado);
                                         if(resultado){
                                        
                                            System.out.println("A sala de chat está disponível. Tinham:" + quantSalas_Chat);
                                            quantSalas_Chat ++;
                                            ProgramServer.setNumSalasChat(quantSalas_Chat);//Incrementa a sala de chat do servidor                                          
                                            
                                            ProgramServer.removeDonosSalaChat(usuario);
                                            System.out.println("Agora os usuários que estão usando as salas de chat são: "+ ProgramServer.getDonosSalaChat());
                                            
                                            System.out.println("Uma sala de chat foi incrementada. Agora tem:" + quantSalas_Chat);
                                            pacoteConfirmacao = new Pacote(TipoPacote.SALA_CHAT_LIBERADA, "SALA_CHAT_LIBERADA");
                                            enviarMsn(pacoteConfirmacao);
                                         }else{
                                             pacoteConfirmacao = new Pacote(TipoPacote.SALA_CHAT_NAO_LIBERADA, "SALA_CHAT_NAO_LIBERADA");
                                             System.out.println("Sala de chat nao liberada:" + quantSalas_Chat);
                                             enviarMsn(pacoteConfirmacao);
                                         }
                                            
                                 //SE A REQUISÃO FOR PARA A SALA DE VÍDEO AO SERVIDOR:           
                                }else if(pacoteRecebido.getTipo() == TipoPacote.REQUISITAR_SALA_VIDEO){
                                    
                                        int quantSalas_Video = ProgramServer.getNumSalasVideo();
                                        Pacote pacoteConfirmacao;
                                        
                                        if( quantSalas_Video == 1){//Tem sala de vídeo, então decrementa logo em seguida
                                            
                                            System.out.println("Existem Salas Disponíveis no Servidor: " + quantSalas_Video);
                                            quantSalas_Video--;
                                            ProgramServer.setNumSalasVideo(quantSalas_Video);//Incrementa a sala de chat do servidor
                                            System.out.println("Uma sala de video foi decrementada. Agora tem:" + ProgramServer.getNumSalasVideo());
                                            pacoteConfirmacao = new Pacote(TipoPacote.TEM_SALA_VIDEO, "TEM_SALA_VIDEO");
                                            enviarMsn(pacoteConfirmacao);
                                        
                                        }
                                        else{
                                            pacoteConfirmacao = new Pacote(TipoPacote.NEGADO_SALA_VIDEO, "NEGADO_SALA_VIDEO");
                                            enviarMsn(pacoteConfirmacao);   
                                            System.out.println("A sala de vídeo está ocupada---->Servidor");
                                        }         
                                }//SE A REQUISÃO FOR PARA LIBERAR A SALA DE VÍDEO:           
                                else if(pacoteRecebido.getTipo() == TipoPacote.LIBERAR_SALA_VIDEO){
                                    
                                        int quantSalas_Video = ProgramServer.getNumSalasVideo();
                                        Pacote pacoteConfirmacao;
                                        
                                        if( quantSalas_Video == 0){//Se não há uma sala de vídeo disponível:
                                            
                                            System.out.println("A sala de vídeo foi incrementada. Tinham:" + quantSalas_Video);
                                            quantSalas_Video++;
                                            ProgramServer.setNumSalasVideo(quantSalas_Video);//Incrementa a sala de vídeo do servidor
                                            System.out.println("Uma sala de vídeo foi incrementada. Agora tem:" + ProgramServer.getNumSalasVideo());
                                            pacoteConfirmacao = new Pacote(TipoPacote.SALA_VIDEO_LIBERADA, "SALA_VIDEO_LIBERADA");
                                            enviarMsn(pacoteConfirmacao);
                                        
                                        }
                                      
                                
                                }else if(pacoteRecebido.getTipo() == TipoPacote.REQUISITAR_EMOTICON){
                                    
                                        int quantTela_Emoticon = ProgramServer.getNumTelaEmoticon();
                                        Pacote pacoteConfirmacao;
                                        
                                        if( quantTela_Emoticon == 1){                                            
                                            
                                            quantTela_Emoticon--;
                                            ProgramServer.setNumTelaEmoticon(quantTela_Emoticon);
                                            ArrayList<ImageIcon> imageIcon = new ArrayList<ImageIcon>();
                                            for (int i = 10; i < 54; i++) {

                                                imageIcon.add(new ImageIcon("Emoticon" + i + ".gif"));

                                            }
                                            pacoteConfirmacao = new Pacote(TipoPacote.TEM_EMOTICON, imageIcon);
                                            enviarMsn(pacoteConfirmacao);
                                        
                                        }
                                        else{
                                            pacoteConfirmacao = new Pacote(TipoPacote.NEGADO_EMOTICON, "NEGADO_EMOTICON");
                                            enviarMsn(pacoteConfirmacao);
                                        }         
                                }        
                                else if(pacoteRecebido.getTipo() == TipoPacote.LIBERAR_EMOTICON){
                                    
                                        int quantTela_Emoticon = ProgramServer.getNumTelaEmoticon();
                                        Pacote pacoteConfirmacao;
                                        
                                        if( quantTela_Emoticon == 0){                                           
                                            
                                            quantTela_Emoticon++;
                                            ProgramServer.setNumTelaEmoticon(quantTela_Emoticon);                                      
                                            pacoteConfirmacao = new Pacote(TipoPacote.EMOTICON_LIBERADO, "EMOTICON_LIBERADO");
                                            enviarMsn(pacoteConfirmacao);
                                        
                                        }
                                      
                                
                                }
                                
			}

		} catch (IOException exc) {


			System.out.println("ANTES: " + usuario.getStatus());
			BancoDeClientes bancoDeClientes = new BancoDeClientes(ProgramServer.getBancoDeClientes());
			if (bancoDeClientes.clienteOff(usuario)) {//Muda Status do Cliente para offline
				ProgramServer.setBancoDeClientes(bancoDeClientes);
				System.out.println("DEPOIS: " + usuario.getStatus());
				encerrarConexao(); // encerra a conexão com o cliente
			}   
			System.out.println(exc.toString() + "\n" + "A conexão com o cliente foi encerrada- Exceção");


		} catch (ClassNotFoundException ex) {
			Logger.getLogger(TrataCliente.class.getName()).log(Level.SEVERE, null, ex);
			System.out.println(ex.toString() + "\n" + "Processamento de com Problemas");
		}
	}

	//Envia qualquer pacote ao Cliente
	public void enviarMsn(Pacote mensagem) throws IOException {
		//Envia o Objeto 
		output.writeObject(mensagem);
		output.flush();
	}

	public void enviarEmail(Pacote mensagem) throws IOException {
	}

	public void encerrarConexao() throws IOException {


		output.close(); //fecha fluxo de saída
		input.close(); //fecha fluxo de entrada
		conexao.close(); //fecha conexão
	}
}
